package com.xtkj.superclub_photo.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.xtkj.commons.SnowflakeIdWorker;
import com.xtkj.superclub_entity.entity.photo.*;
import com.xtkj.superclub_photo.client.IFastDfsClient;
import com.xtkj.superclub_photo.dao.*;
import com.xtkj.superclub_photo.service.IPhotoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

@Service
public class PhotoServiceImpl implements IPhotoService {

    @Autowired
    private ITeamAlbumDao teamAlbumDao;

    @Autowired
    private IActivityAlbumDao activityAlbumDao;

    @Autowired
    private IActivityPhotoDao activityPhotoDao;

    @Autowired
    private ITeamUserAlbumDao teamUserAlbumDao;

    @Autowired
    private ITeamUserPhotoDao teamUserPhotoDao;

    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;

    @Autowired
    private IPersonalAlbumDao personalAlbumDao;

    @Autowired
    private IPersonalSomeAlbumDao personalSomeAlbumDao;

    @Autowired
    private IPersonalSomePhotoDao personalSomePhotoDao;

    @Autowired
    private IFastDfsClient fastDfsClient;

    /*
    查询驴友队下的相册 包括活动相册和用户相册
    * */
    @Override
    public List<Map<String, Object>> tourPalAlbumList(String teamAlbumId) {
        //List集合装所有的相册及其相册对应的照片
        List<Map<String, Object>> teamAllAlbums = new ArrayList<Map<String, Object>>();

        //根据用户传入的驴友队id 查询当前驴友队下的所有的活动相册id
        QueryWrapper wrapper1 = new QueryWrapper<>().eq("team_album_id",teamAlbumId).eq("album_type",1);

        //当前驴友队相册下的所有的活动相册
        List<TeamAlbum> teamActivityAlbums = teamAlbumDao.selectList(wrapper1);

        //根据用户传入的驴友队id 查询当前驴友队下的所有的用户自建相册id
        QueryWrapper wrapper4 = new QueryWrapper<>().eq("team_album_id",teamAlbumId).eq("album_type",0);

        //当前驴友队相册下的所有的用户相册
        List<TeamAlbum> teamUserAlbums = teamAlbumDao.selectList(wrapper4);

        //循环拿到每个活动相册里面的照片
        for(int i = 0;i<teamActivityAlbums.size();i++){

            //map存放每个相册的信息，即 相册的信息 和 相册下面照片的信息
            Map<String,Object> albumInfo = new HashMap<String,Object>();

            //拿到相册id
            String albumId = teamActivityAlbums.get(i).getAlbumId();

            //拿到当前相册下的所有照片id
            QueryWrapper wrapper2 = new QueryWrapper<>().eq("activity_album_id",albumId);
            List<ActivityAlbum> activityAlbum = activityAlbumDao.selectList(wrapper2);
            List<String> activityPhotoIds = new ArrayList<String>();
            for (int j = 0;j<activityAlbum.size();j++){
                activityPhotoIds.add(j,activityAlbum.get(j).getActivityPhotoId());
            }

            //根据拿到的照片id 查询照片
            QueryWrapper wrapper3 = new QueryWrapper<>().in("activity_photo_id",activityPhotoIds);

            //拿到相册里面的所有的照片
            List<ActivityPhoto> activityPhotos = activityPhotoDao.selectList(wrapper3);

            //将相册信息和他的所有的照片放入map
            albumInfo.put("ativityAlbum",teamActivityAlbums.get(i));
            albumInfo.put("activityPhotos",activityPhotos);

            //将map放入list中
            teamAllAlbums.add(i,albumInfo);
        }

        //循环拿到每个用户相册里面的照片
        for (int i = 0;i<teamUserAlbums.size();i++){

            //map存放每个相册的信息，即 相册的信息 和 相册下面照片的信息
            Map<String,Object> albumInfo = new HashMap<String,Object>();

            //拿到相册id
            String albumId = teamUserAlbums.get(i).getAlbumId();

            //拿到当前相册下的所有照片id
            QueryWrapper wrapper5 = new QueryWrapper<>().eq("user_album_id",albumId);
            List<TeamUserAlbum> teamUserAlbum = teamUserAlbumDao.selectList(wrapper5);
            List<String> teamUserPhotoIds = new ArrayList<String>();
            for (int j = 0;j<teamUserAlbum.size();j++){
                teamUserPhotoIds.add(j,teamUserAlbum.get(j).getUserPhotoId());
            }

            //根据拿到的照片id 查询照片
            QueryWrapper wrapper6 = new QueryWrapper<>().in("user_photo_id",teamUserPhotoIds);

            //拿到相册里面的所有的照片
            List<TeamUserPhoto> teamUserPhotos = teamUserPhotoDao.selectList(wrapper6);

            //将相册信息和他的所有的照片放入map
            albumInfo.put("userAlbum",teamUserAlbums.get(i));
            albumInfo.put("userPhotos",teamUserPhotos);

            //将map放入list
            teamAllAlbums.add(i+teamActivityAlbums.size(),albumInfo);
        }

        return teamAllAlbums;
    }

    /*
    新建相册，包括驴友队里面的 活动相册 ， 用户相册 ；个人中心里的 游记相册 ， 朋友圈相册 ， 默认相册

        活动相册：创建活动时会创建一个相册 ，在z_activity_album中插入数据 ， 如果是驴友队活动
                 还需在z_team_album中插入数据 ， 如果是私人活动则不需要 。
        驴友队用户相册： 用户可以在驴友队中创建用户相册 ，首先在z_team_user_album中插入数据 ，然后在
                       z_team_album中插入数据
        个人相册：其中默认存在两个先出个- 1、默认相册 2、游记相册
                 在个人中心创建用户相册则分别需要在z_personal_album表和z_personal_some_album表中插入数据
        * */

    //新建驴友队活动相册
    @Override
    public void newAlBumList(Map<String,Object> albumInfo){
        //判断map中的Type参数
        String Type = albumInfo.get("Type")+"";
        /*
        Type==activity , 创建活动相册
            需要参数：activity_album_id ， 当前服务层雪花id生产
                     activity_id , 从map中取得
                     判断map中是否有tean_album_id,如果有需要操作team_album表
                        team_album_id , 从map中取的
                        album_id , 上面雪花生成的
                        album_name , 从map中取得
                        album_type , 活动相册此字段为1
        * */
        //活动相册id
        if("activity".equals(Type)){

            String albumId = snowflakeIdWorker.nextId()+"";

            ActivityAlbum activityAlbum = new ActivityAlbum(albumId,null,albumInfo.get("activityId")+"",new Date());

            //插入数据
            activityAlbumDao.insert(activityAlbum);

            if (albumInfo.get("teamAlbumId")!=null){
                //插入数据
                TeamAlbum teamAlbum = new TeamAlbum(albumInfo.get("teamAlbumId")+"",albumId,albumInfo.get("albumName")+"",1,new Date());

                teamAlbumDao.insert(teamAlbum);
            }
        }
        /*
            Type==user , 创建用户相册
            需要参数：   user_album_id ， 当前服务层雪花id生产  album_id , 上面雪花生成的
                        team_album_id , 从map中取的
                        album_name , 从map中取得
                        album_type , 用户相册此字段为0
        * */
        //用户相册
        if("user".equals(Type)){
            //用户相册id，雪花id生成
            String albumId = snowflakeIdWorker.nextId()+"";
            //在z_team_user_album中插入数据
            TeamUserAlbum teamUserAlbum = new TeamUserAlbum(albumId,null,new Date());
            teamUserAlbumDao.insert(teamUserAlbum);
            //并且在z_team_album表中插入数据
            TeamAlbum teamAlbum = new TeamAlbum(albumInfo.get("teamAlbumId")+"",albumId,albumInfo.get("albumName")+"",0,new Date());
            teamAlbumDao.insert(teamAlbum);
        }

        /*
            Type==personal , 创建个人中心的个人相册
            需要参数：   personal_album_id , 每个用户对应一个personal_album_id ，
                        album_id , 雪花id生成的
                        album_name , 用户传进来的 ， 从map中获取
                        album_type , 1为用户创建的

                        some_album_id = album_id , 上面的
                        some_photo_id , 创建相册是一张照片没有


        * */
        //个人相册
        if("personal".equals(Type)){
            //生成一个相册id
            String albumId = snowflakeIdWorker.nextId()+"";
            //在z_personal_some_album插入数据，构建实体类
            PersonalSomeAlbum personalSomeAlbum = new PersonalSomeAlbum(albumId,null,new Date());
            personalSomeAlbumDao.insert(personalSomeAlbum);
            // 并且在z_personal_album中插入数据 ， 构建实体类
            PersonalAlbum personalAlbum = new PersonalAlbum(albumInfo.get("personalAlbumId")+"",albumId,albumInfo.get("albumName")+"",1,new Date());
            personalAlbumDao.insert(personalAlbum);
        }




    }

    //删除相册
    @Override
    @Transactional
    public void cleanAlBumList(String oneAlbumId,String Type) {
        /*
        删除相册 ： 1、删除活动相册
                        （1）删除z_activity_photo表里的当前相册的所有的照片
                        （2）删除z_activity_album表的相册信息
                        （3）如果是驴友队相册，则还需要删除z_team_album中相关的数据
                         (4)删除文件服务器上的照片
                   2、删除用户相册
                        （1）删除z_team_user_photo表里的当前相册的所有的照片
                        （2）删除z_team_user_album表的相册信息
                        （3）删除z_team_album中相关的数据
                         (4)删除文件服务器上的照片
                   3、删除个人相册
                        （1）删除z_personal_some_photo表里的当前相册的所有的照片
                        （2）删除z_personal_some_album表的相册信息
                        （3）删除z_personal_album中相关的数据
                         (4)删除文件服务器上的照片
        * */
        //删除活动相册
        if("activity".equals(Type)){
            //查询该相册下所有的照片id
            QueryWrapper wrapper1 = new QueryWrapper<>().eq("activity_album_id",oneAlbumId);
            List<ActivityAlbum> activityAlbum = activityAlbumDao.selectList(wrapper1);
            List<String> activityPhotoIds = new ArrayList<String>();
            for (int i = 0;i<activityAlbum.size();i++){
                activityPhotoIds.add(i,activityAlbum.get(i).getActivityPhotoId());
            }

            QueryWrapper wrapper2 = new QueryWrapper<>().in("activity_photo_id",activityPhotoIds);

            //删除文件服务器上的照片 , 拿到该相册下的所有的照片路径 ， 循环从文件服务器上删除
            List<ActivityPhoto> activityPhotos = activityPhotoDao.selectList(wrapper2);
            int conut = 0;
            for (int i = 0;i<activityPhotos.size();i++){
                fastDfsClient.deleteFile(activityPhotos.get(i).getActivityPhotoUrl());
                System.out.println("删除 "+activityPhotos.get(i).getActivityPhotoUrl()+" 成功");
                conut++;
            }
            System.out.println("总计从文件服务器上删除了"+conut+"张照片");

            //删除z_activity_photo表里的当前相册的所有的照片
            activityPhotoDao.delete(wrapper2);

            //删除z_activity_album表的相册信息
            activityAlbumDao.delete(wrapper1);

            //删除z_team_album中相关的数据
            QueryWrapper wrapper3 = new QueryWrapper<>().eq("album_id",oneAlbumId);
            teamAlbumDao.delete(wrapper3);

        }
        //删除用户相册
        if("user".equals(Type)){
            //查询该相册下所有的照片id
            QueryWrapper wrapper1 = new QueryWrapper<>().eq("user_album_id",oneAlbumId);
            List<TeamUserAlbum> teamUserAlbum = teamUserAlbumDao.selectList(wrapper1);
            List<String> userPhotoIds = new ArrayList<String>();
            for (int i = 0;i<teamUserAlbum.size();i++){
                userPhotoIds.add(i,teamUserAlbum.get(i).getUserPhotoId());
            }

            QueryWrapper wrapper2 = new QueryWrapper<>().in("user_photo_id",userPhotoIds);

            //删除文件服务器上的照片 , 拿到该相册下的所有的照片路径 ， 循环从文件服务器上删除
            List<TeamUserPhoto> teamUserPhotos = teamUserPhotoDao.selectList(wrapper2);
            int conut = 0;
            for (int i = 0;i<teamUserPhotos.size();i++){
                fastDfsClient.deleteFile(teamUserPhotos.get(i).getUserPhotoUrl());
                System.out.println("删除 "+teamUserPhotos.get(i).getUserPhotoUrl()+" 成功");
                conut++;
            }
            System.out.println("总计从文件服务器上删除了"+conut+"张照片");

            //删除z_team_user_photo表里的当前相册的所有的照片
            teamUserPhotoDao.delete(wrapper2);

            //删除z_team_user_album表的相册信息
            teamUserAlbumDao.delete(wrapper1);

            //删除z_team_album中相关的数据
            QueryWrapper wrapper3 = new QueryWrapper<>().eq("album_id",oneAlbumId);
            teamAlbumDao.delete(wrapper3);

        }
        //删除个人相册
        if("personal".equals(Type)){
            //查询该相册下所有的照片id
            QueryWrapper wrapper1 = new QueryWrapper<>().eq("some_album_id",oneAlbumId);
            List<PersonalSomeAlbum> personalSomeAlbum = personalSomeAlbumDao.selectList(wrapper1);
            List<String> somePhotoIds = new ArrayList<String>();
            for (int i = 0;i<personalSomeAlbum.size();i++){
                somePhotoIds.add(i,personalSomeAlbum.get(i).getSomePhotoId());
            }

            QueryWrapper wrapper2 = new QueryWrapper<>().in("some_photo_id",somePhotoIds);

            //删除文件服务器上的照片 , 拿到该相册下的所有的照片路径 ， 循环从文件服务器上删除
            List<PersonalSomePhoto> personalSomePhotos = personalSomePhotoDao.selectList(wrapper2);
            int conut = 0;
            for (int i = 0;i<personalSomePhotos.size();i++){
                fastDfsClient.deleteFile(personalSomePhotos.get(i).getSomePhotoUrl());
                System.out.println("删除 "+personalSomePhotos.get(i).getSomePhotoUrl()+" 成功");
                conut++;
            }
            System.out.println("总计从文件服务器上删除了"+conut+"张照片");

            //删除z_personal_some_photo表里的当前相册的所有的照片
            personalSomePhotoDao.delete(wrapper2);

            //删除z_personal_some_album表的相册信息
            personalSomeAlbumDao.delete(wrapper1);

            //删除z_personal_album中相关的数据
            QueryWrapper wrapper3 = new QueryWrapper<>().eq("album_id",oneAlbumId);
            personalAlbumDao.delete(wrapper3);


        }
    }


    //添加相片到相册
    /*
    map集合参数： 相册id ： 说明往哪个相册里插入数据 mAlbumId
                 照片路径 ：。。。。 mPhotoUrl 是个list集合
                 相册类型Type ： 说明操作哪种类型的相册 mType
    * */
    @Override
    @Transactional
    public void addPhotoToAlBum(Map<String, Object> albumAndPhotoInfo) {
        //拿到要操作的相册类型
        String type = albumAndPhotoInfo.get("mType") + "";

        /*
            操作活动相册 : 首先往 表z_activity_albumz中插入数据
                            activity_album_id : map集合中获取
                            activity_photo_id ： 由雪花id生成
                            activity_id : 活动id 由相册id查询而出
                          并且往 表z_activity_photo中插入数据
                            activity_photo_id : 上表中已经由雪花id生成
                            activity_photo_url : map集合中获取
        * */
        if ("activity".equals(type)) {

            //相册id
            String activityAlbumId = albumAndPhotoInfo.get("mAlbumId") + "";

            //根据活动相册id查到活动id
            QueryWrapper wrapper1 = new QueryWrapper<>().eq("activity_album_id", activityAlbumId);
            List<ActivityAlbum> activityAlbums = activityAlbumDao.selectList(wrapper1);
            String activityId = activityAlbums.get(0).getActivityId();

            //照片路径集合
            List<String> activityPhotoUrls = (List<String>)albumAndPhotoInfo.get("mPhotoUrl");

            //照片id集合
            List<String> activityPhotoIds = new ArrayList<String>();

            for (int i = 0;i<activityPhotoUrls.size();i++){
                activityPhotoIds.add(i,snowflakeIdWorker.nextId()+"");
            }

            //往 表z_activity_album中插入数据
            for (int i = 0;i<activityPhotoIds.size();i++){
                ActivityAlbum activityAlbumx = new ActivityAlbum(activityAlbumId,activityPhotoIds.get(i),activityId,new Date());
                activityAlbumDao.insert(activityAlbumx);
            }

            //往 表z_activity_photo中插入数据
            for (int i = 0;i<activityPhotoUrls.size();i++){
                ActivityPhoto activityPhoto = new ActivityPhoto(activityPhotoIds.get(i),activityPhotoUrls.get(i),new Date());
                activityPhotoDao.insert(activityPhoto);
            }

        }

        /*
            操作用户相册 : 首先往 表z_team_user_album中插入数据
                            user_album_id : map集合中获取
                            user_photo_id ： 由雪花id生成
                          并且往 表z_team_user_photo中插入数据
                            user_photo_id : 上表中已经由雪花id生成
                            user_photo_url : map集合中获取
        * */
        if ("user".equals(type)) {
            //用户相册id
            String userAlbumId = albumAndPhotoInfo.get("mAlbumId") + "";

            //图片路径集合
            List<String> userPhotoUrls = (List<String>)albumAndPhotoInfo.get("mPhotoUrl");

            //照片id集合
            List<String> userPhotoIds = new ArrayList<String>();
            for (int i = 0;i<userPhotoUrls.size();i++){
                userPhotoIds.add(i,snowflakeIdWorker.nextId()+"");
            }

            //往 表z_team_user_album中插入数据
            for (int i = 0;i<userPhotoIds.size();i++){
                TeamUserAlbum teamUserAlbum = new TeamUserAlbum(userAlbumId,userPhotoIds.get(i),new Date());
                teamUserAlbumDao.insert(teamUserAlbum);
            }

            //往 表z_team_user_photo中插入数据
            for (int i = 0;i<userPhotoUrls.size();i++){
                TeamUserPhoto teamUserPhoto = new TeamUserPhoto(userPhotoIds.get(i),userPhotoUrls.get(i),new Date());
                teamUserPhotoDao.insert(teamUserPhoto);
            }


        }

        /*
            操作个人相册 :
                        首先 z_personal_some_album 插入数据
                            some_album_id , map集合获取
                            some_photo_id , 雪花id生成
                        并且 z_personal_some_photo 插入数据
                            some_photo_id ,上面雪花id生成
                            some_photo_url , map集合中获取

        * */
        if ("personal".equals(type)) {
            //some_album_id , map集合获取
            String someAlbumId = albumAndPhotoInfo.get("mAlbumId")+"";

            //照片路径集合
            List<String> somePhotoUrls = (List<String>)albumAndPhotoInfo.get("mPhotoUrl");

            //some_photo_id 集合, 雪花id生成
            List<String> somePhotoIds = new ArrayList<String>();
            for (int i = 0;i<somePhotoUrls.size();i++){
                somePhotoIds.add(i,snowflakeIdWorker.nextId()+"");
            }

            //z_personal_some_album 插入数据
            int count = 0;
            for (int i = 0;i<somePhotoIds.size();i++){
                PersonalSomeAlbum personalSomeAlbum = new PersonalSomeAlbum(someAlbumId,somePhotoIds.get(i),new Date());
                personalSomeAlbumDao.insert(personalSomeAlbum);
                count++;
            }
            System.out.println("在表z_personal_some_album中插入了"+count+"条数据");

            //z_personal_some_photo 插入数据
            count = 0;
            for (int i = 0;i<somePhotoUrls.size();i++){
                PersonalSomePhoto personalSomePhoto = new PersonalSomePhoto(somePhotoIds.get(i),somePhotoUrls.get(i),new Date());
                personalSomePhotoDao.insert(personalSomePhoto);
                count++;
            }
            System.out.println("在表z_personal_some_photo中插入了"+count+"条数据");
        }

    }

    //给琪琪调的 , 拿到游记相册id
    @Override
    public String getAlbumId(String personalAlbumId){

        //根据personalAlbumId查询AlbumId
        QueryWrapper wrapper = new QueryWrapper<>().eq("personal_album_id",personalAlbumId)
                .eq("album_name","游记相册").eq("album_type",0);

        PersonalAlbum personalAlbum = personalAlbumDao.selectOne(wrapper);

        return personalAlbum.getAlbumId();
    }


    //从相册中删除照片
    /*
    map集合参数： 相册id ： 说明从哪个相册里删除数据 mAlbumId
                 照片路径id ：。。。。 mPhotoId 是个list集合
                 相册类型Type ： 说明操作哪种类型的相册 mType
    * */
    @Override
    @Transactional
    public void deletePhotoFromAlbum(Map<String, Object> albumAndPhotoInfo) {
        //拿到要操作的相册类型
        String type = albumAndPhotoInfo.get("mType") + "";

        if ("activity".equals(type)){
            //拿到要操作的相册id
            String albumId = albumAndPhotoInfo.get("mAlbumId")+"";

            //要删除的照片id
            List<Object> activityPhotoIds = (List<Object>)albumAndPhotoInfo.get("mPhotoId");
            List<String> activityPhotoIds1 = new ArrayList<String>();
            for (int i = 0;i<activityPhotoIds.size();i++){
                activityPhotoIds1.add(i,activityPhotoIds.get(i).toString());
            }

            //根据要删除的照片id查询对应的url List《string》
            QueryWrapper wrapper1 = new QueryWrapper<>().in("activity_photo_id",activityPhotoIds1);
            List<ActivityPhoto> activityPhotos = activityPhotoDao.selectList(wrapper1);

            //先删除文件服务器上的照片
            for (int i = 0;i<activityPhotos.size();i++){
                fastDfsClient.deleteFile(activityPhotos.get(i).getActivityPhotoUrl());
                System.out.println("从文件服务器上删除 "+activityPhotos.get(i).getActivityPhotoUrl()+" 成功");
            }

            //删除z_activity_photo对应的数据
            activityPhotoDao.delete(wrapper1);

            //删除z_activity_album对应的数据
            activityAlbumDao.delete(wrapper1);
        }

        if("user".equals(type)){
            //拿到要操作的相册id
            String albumId = albumAndPhotoInfo.get("mAlbumId")+"";

            //要删除的照片id
            List<Object> userPhotoIds = (List<Object>)albumAndPhotoInfo.get("mPhotoId");
            List<String> userPhotoIds1 = new ArrayList<String>();
            for (int i = 0;i<userPhotoIds.size();i++){
                userPhotoIds1.add(i,userPhotoIds.get(i).toString());
            }

            //根据要删除的照片id查询对应的url List《string》
            QueryWrapper wrapper1 = new QueryWrapper<>().in("user_photo_id",userPhotoIds1);
            List<TeamUserPhoto> teamUserPhotos = teamUserPhotoDao.selectList(wrapper1);

            System.out.println(userPhotoIds);
            System.out.println("teamUserPhotos is "+teamUserPhotos.size());

            //先删除文件服务器上的照片
            for (int i = 0;i<teamUserPhotos.size();i++){
                fastDfsClient.deleteFile(teamUserPhotos.get(i).getUserPhotoUrl());
                System.out.println("从文件服务器上删除 "+teamUserPhotos.get(i).getUserPhotoUrl()+" 成功");
            }

            //删除z_team_user_photo对应的数据
            teamUserPhotoDao.delete(wrapper1);

            //删除z_team_user_album对应的数据
            teamUserAlbumDao.delete(wrapper1);

        }

        if("personal".equals(type)){
            //拿到要操作的相册id
            String albumId = albumAndPhotoInfo.get("mAlbumId")+"";

            //要删除的照片id
            List<Object> somePhotoIds = (List<Object>)albumAndPhotoInfo.get("mPhotoId");
            List<String> somePhotoIds1 = new ArrayList<String>();
            for (int i = 0;i<somePhotoIds.size();i++){
                somePhotoIds1.add(i,somePhotoIds.get(i).toString());
            }

            //根据要删除的照片id查询对应的url List《string》
            QueryWrapper wrapper1 = new QueryWrapper<>().in("some_photo_id",somePhotoIds1);
            List<PersonalSomePhoto> personalSomePhotos = personalSomePhotoDao.selectList(wrapper1);

            System.out.println(somePhotoIds1);
            System.out.println("personalSomePhotos is "+personalSomePhotos.size());

            //先删除文件服务器上的照片
            for (int i = 0;i<personalSomePhotos.size();i++){
                fastDfsClient.deleteFile(personalSomePhotos.get(i).getSomePhotoUrl());
                System.out.println("从文件服务器上删除 "+personalSomePhotos.get(i).getSomePhotoUrl()+" 成功");
            }

            //删除z_personal_some_photo对应的数据
            personalSomePhotoDao.delete(wrapper1);

            //删除z_personal_some_album对应的数据
            personalSomeAlbumDao.delete(wrapper1);



        }
    }


}
